home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / libs / sphigs / sph_mac.hqx / SRGP port to 5.0 (compressed) / SRGP_SPHIGS Root / MacSRGP / srgp_input.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-02-13  |  12.7 KB  |  570 lines
  1. #include "HEADERS.h"
  2. #include "srgplocal.h"
  3. #ifdef UNIX
  4. #   include <sys/types.h>
  5. #   include <sys/time.h>
  6. #endif
  7.  
  8. #include "srgp_input.proto.h"
  9. static void ComputeTimestamp(srgp_timestamp *);
  10.  
  11.  
  12. /** DEVICE INDEPENDENCE
  13. This file contains functions that are device-independent,
  14.    except for the "sleeping" arrangements for SRGP_waitEvent.
  15. Refer to inputraw.c and echo.c for the low-level "drivers" 
  16.    for each type of implementation.
  17.  
  18. **/
  19.  
  20.  
  21. static void
  22. ComputeTimestamp (srgp_timestamp *ts)
  23. {
  24.    Time tdiff =  srgpx__cur_time - srgpx__starttime;
  25.  
  26.    ts->seconds = tdiff / rawgranularity;
  27.    ts->ticks = (tdiff % rawgranularity) / ((double)rawgranularity) * 60;
  28. }
  29.  
  30.  
  31.  
  32. /** SRGP __ initInputModule **/
  33. void
  34. SRGP__initInputModule (void)
  35. {
  36.    /* DEFAULT KEYBOARD ECHO POSITION IS MIDDLE OF SCREEN WINDOW. */
  37.    srgp__cur_keyboard_echo_origin = 
  38.       SRGP_defPoint(srgp__canvasTable[0].max_xcoord >> 1,
  39.             srgp__canvasTable[0].max_ycoord >> 1);
  40.    srgp__cur_locator_echo_anchor = srgp__cur_keyboard_echo_origin;
  41.  
  42.    /* DEFAULT KEYBOARD ATTRIBUTES */
  43.    srgp__cur_keyboard_echo_font = 0;
  44.    srgp__cur_keyboard_echo_color = SRGP_BLACK;
  45.  
  46.    SRGP__disableLocatorCursorEcho();
  47.  
  48.    /* INITIALIZE CURSOR TABLE. */
  49.    PUSH_TRACE;
  50.    /* SRGP_loadCursor (0, XC_arrow);    "device" dependent!!! */
  51.    POP_TRACE;
  52.    srgp__cur_cursor = 0;
  53.  
  54.    /* INITIALIZE ACTIVITY INFORMATION. */
  55.    srgp__cur_mode[LOCATOR]=srgp__cur_mode[KEYBOARD]=INACTIVE;
  56.    srgp__cur_locator_echo_type = CURSOR;
  57.    srgp__cur_keyboard_processing_mode = EDIT;
  58.  
  59.    /* INITIALIZE MEASURES AND MASKS */
  60.    srgp__cur_locator_measure.button_chord[LEFT_BUTTON] = UP;
  61.    srgp__cur_locator_measure.button_chord[MIDDLE_BUTTON] = UP;
  62.    srgp__cur_locator_measure.button_chord[RIGHT_BUTTON] = UP;
  63.    srgp__cur_locator_measure.position = srgp__cur_locator_echo_anchor;
  64.  
  65.    srgp__cur_keyboard_measure.buffer = malloc(MAX_STRING_SIZE+1);
  66.    srgp__cur_keyboard_measure.buffer_length = MAX_STRING_SIZE+1;
  67.    srgp__cur_keyboard_measure.buffer[0] = '\0';
  68.    srgp__get_keyboard_measure.buffer = malloc(MAX_STRING_SIZE+1);
  69.    srgp__get_keyboard_measure.buffer_length = MAX_STRING_SIZE+1;
  70.    srgp__get_keyboard_measure.buffer[0] = '\0';
  71.  
  72.    srgp__cur_locator_button_mask = LEFT_BUTTON_MASK;
  73.  
  74.    SRGP__initInputDrivers ();
  75.    SRGP__initEchoModule ();
  76. }
  77.    
  78.  
  79.  
  80.  
  81. /** SRGP set input mode
  82. The device is first deactivated, then its cur_mode status is updated,
  83. then it is activated
  84. **/
  85. void
  86. SRGP_setInputMode (inputDevice device, inputMode mode)
  87. {
  88.    DEBUG_AIDS{
  89.       SRGP_trace (SRGP_logStream, "SRGP_setInputMode  %d into %d\n", 
  90.           device, mode);
  91.       srgp_check_system_state();
  92.       srgp_check_device (device);
  93.       srgp_check_mode (mode);
  94.       LeaveIfNonFatalErr();
  95.    }
  96.  
  97.    if (mode == srgp__cur_mode[device])
  98.       /* NOTHING IS TO BE DONE. */
  99.       return;
  100.  
  101.    if (mode == INACTIVE) {
  102.       /* WE ARE BRINGING AN ACTIVE DEVICE TO INACTIVITY. */
  103.       SRGP__deactivateDevice (device);
  104.       srgp__cur_mode[device] = INACTIVE;
  105.    }
  106.  
  107.    else {
  108.       if ((device==LOCATOR)&&(srgp__cur_mode[LOCATOR]==INACTIVE))
  109.      SRGP__updateRawCursorPosition();
  110.       srgp__cur_mode[device] = mode;
  111.       SRGP__activateDevice (device);
  112.    }
  113. }
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120. /** SRGP wait event
  121. The event in the queue which satisfies the wait is removed
  122. and placed at the tail of the free-list.  It is there that
  123. the "get" routines look.
  124.  
  125. Returns the identifier of the device which issued the event.
  126.    (NO_DEVICE if none).
  127. **/
  128.  
  129. inputDevice
  130. SRGP_waitEvent (int maximum_wait_time)
  131. {
  132. #ifdef X11
  133.    struct timeval tp, tzp, expiretime, timeout, *timeout_ptr;
  134.    int fd;
  135.    fd_set readfds;
  136. #endif
  137. #ifdef THINK_C   
  138.    Time curtime, expiretime=0;
  139. #endif
  140.    int return_value;
  141.    boolean do_continue_wait, do_continue_search;
  142.    boolean forever = (maximum_wait_time < 0);
  143.  
  144.  
  145.    DEBUG_AIDS{
  146.       srgp_check_system_state();
  147.       LeaveIfNonFatalErr();
  148.    }
  149.  
  150.  
  151. #ifdef UNIX
  152. #define MILLION 1000000
  153.    FD_ZERO (&readfds);
  154.    FD_SET (fd=ConnectionNumber(srgpx__display), &readfds);
  155.  
  156.    /* INITIALIZE (if necessary) TIMING INFORMATION */
  157.    if (maximum_wait_time > 0) {
  158.       long maxwait_sec, maxwait_ticks;
  159.       gettimeofday (&tp,&tzp);
  160.       maxwait_sec = maximum_wait_time / 60;
  161.       maxwait_ticks = maximum_wait_time % 60;
  162.       expiretime.tv_usec = tp.tv_usec + (maxwait_ticks*MILLION/60);
  163.       expiretime.tv_sec = tp.tv_sec + maxwait_sec + 
  164.                       (expiretime.tv_usec / MILLION);
  165.       expiretime.tv_usec %= MILLION;
  166.    }
  167. #endif
  168.  
  169. #ifdef THINK_C
  170.    expiretime = TickCount() + maximum_wait_time;
  171. #endif
  172.  
  173.    do_continue_wait = TRUE;
  174.  
  175.    return_value = NO_DEVICE;  /* timeout is what we assume will happen */
  176.  
  177.  
  178.    /**** LOOP *****/
  179.    do {
  180.       return_value = SRGP__handleRawEvents (TRUE,forever);
  181.  
  182.       if ((return_value != NO_DEVICE) || (maximum_wait_time == 0))
  183.      do_continue_wait = FALSE;
  184.  
  185. #ifdef UNIX
  186.       /* Otherwise, perform a wait state */
  187.       else {
  188.      if (!forever) {
  189.         gettimeofday (&tp,&tzp);
  190.         /* Perform subtraction: expiretime - tp */
  191.         if (expiretime.tv_usec < tp.tv_usec) {
  192.            /* perform a borrow */
  193.            expiretime.tv_sec--;
  194.            expiretime.tv_usec += 1000000;
  195.         }
  196.         timeout_ptr = &timeout;
  197.         timeout.tv_usec = expiretime.tv_usec - tp.tv_usec;
  198.         timeout.tv_sec  = expiretime.tv_sec  - tp.tv_sec;
  199.         if ((timeout.tv_sec < 0) || (timeout.tv_usec < 0))
  200.            /* Whoops!  We've already expired! */
  201.            do_continue_wait = FALSE;
  202.      }
  203.      else /* (maximum_wait_time is negative representing infinity) */
  204.         timeout_ptr = NULL;
  205.  
  206.      if (do_continue_wait)
  207.         if (XPending(srgpx__display) == 0) {
  208.            if (select (fd+1, &readfds, NULL, NULL, timeout_ptr))
  209.           /* An event occurred before the timeout! */
  210.           ;  /* so do nothing */
  211.            else 
  212.           do_continue_wait = FALSE;
  213.         }
  214.       }
  215. #endif
  216.  
  217. #ifdef THINK_C
  218.       else
  219.          if (maximum_wait_time > 0) {
  220.             do_continue_wait =  (TickCount() < expiretime);
  221.          }
  222. #endif
  223.  
  224.    }
  225.    while (do_continue_wait);
  226.  
  227.    srgp__device_at_head_of_queue = return_value;
  228.  
  229.    return return_value;
  230. }
  231.  
  232.  
  233.  
  234. void
  235. SRGP_getLocator (srgp__locator_measure *measure)
  236. {
  237.    DEBUG_AIDS{
  238.       srgp_check_system_state();
  239.       srgp_check_event_type (LOCATOR);
  240.       LeaveIfNonFatalErr();
  241.    }
  242.  
  243.    /* this assignment statement is very risky!  God help me! */
  244.    *measure = *((srgp__locator_measure*)(&srgp__get_locator_measure));
  245. }
  246.  
  247.  
  248. void
  249. SRGP_getDeluxeLocator (srgp__deluxe_locator_measure *measure)
  250. {
  251.    DEBUG_AIDS{
  252.       srgp_check_system_state();
  253.       srgp_check_event_type (LOCATOR);
  254.       LeaveIfNonFatalErr();
  255.    }
  256.  
  257.    *measure = srgp__get_locator_measure;
  258.    ComputeTimestamp (&(measure->timestamp));
  259. }
  260.  
  261.  
  262.  
  263. void
  264. SRGP_getKeyboard (char *measure, int bufsize)
  265. {
  266.    DEBUG_AIDS{
  267.       srgp_check_system_state();
  268.       srgp_check_event_type (KEYBOARD);
  269.       LeaveIfNonFatalErr();
  270.    }
  271.    strncpy (measure, srgp__get_keyboard_measure.buffer, bufsize-1);
  272.    *(measure+bufsize-1) = '\0';
  273. }
  274.  
  275.  
  276. void
  277. SRGP_getDeluxeKeyboard (srgp__deluxe_keyboard_measure *measure)
  278. {
  279.    DEBUG_AIDS{
  280.       srgp_check_system_state();
  281.       srgp_check_event_type (KEYBOARD);
  282.       LeaveIfNonFatalErr();
  283.    }
  284.    strncpy (measure->buffer, srgp__get_keyboard_measure.buffer, 
  285.         measure->buffer_length-1);
  286.    *(measure->buffer+measure->buffer_length-1) = '\0';
  287.    bcopy (srgp__get_keyboard_measure.modifier_chord,
  288.       measure->modifier_chord,
  289.       sizeof(measure->modifier_chord));
  290.    measure->position = srgp__get_keyboard_measure.position;
  291.    
  292.    ComputeTimestamp (&(measure->timestamp));
  293. }
  294.  
  295.  
  296.  
  297.  
  298. /** MEASURE SETTING **/
  299.  
  300. void
  301. SRGP_setLocatorMeasure (point position)
  302. {
  303.    DEBUG_AIDS{
  304.       SRGP_trace (SRGP_logStream, "SRGP_setLocatorMeasure %d,%d\n", 
  305.           position.x, position.y);
  306.       srgp_check_system_state();
  307.       LeaveIfNonFatalErr();
  308.    }
  309.  
  310.    SRGP__handleRawEvents (FALSE,FALSE);
  311.  
  312.    srgp__cur_locator_measure.position = position;
  313.  
  314.    SRGP__updateRawCursorPosition ();
  315. }
  316.  
  317.  
  318. /*!*/
  319. void
  320. SRGP_setKeyboardMeasure (char *str)
  321. {
  322.    DEBUG_AIDS{
  323.       SRGP_trace (SRGP_logStream, "SRGP_setKeyboardMeasure %s\n", str);
  324.       srgp_check_system_state();
  325.       LeaveIfNonFatalErr();
  326.    }
  327.    SRGP__handleRawEvents (FALSE,FALSE);
  328.  
  329.    strncpy (srgp__cur_keyboard_measure.buffer, str, MAX_STRING_SIZE);
  330.    *(srgp__cur_keyboard_measure.buffer+MAX_STRING_SIZE) = '\0';
  331.    srgp__cur_keyboard_measure_length = strlen(srgp__cur_keyboard_measure.buffer);
  332.  
  333.    SRGP__updateKeyboardEcho ();
  334. }
  335.  
  336.  
  337.  
  338.  
  339. /** ATTRIBUTES
  340. The routines allow the application to control the echoing
  341. associated with the keyboard and the locator devices.
  342. **/
  343.  
  344. /*!*/
  345.  
  346. void
  347. SRGP_setLocatorEchoType (echoType value)
  348. {
  349.    DEBUG_AIDS{
  350.       SRGP_trace (SRGP_logStream, "SRGP_setLocatorEchoType %d\n", value);
  351.       srgp_check_system_state();
  352.       srgp_check_locator_echo_type(value);
  353.       LeaveIfNonFatalErr();
  354.    }
  355.  
  356.    SRGP__handleRawEvents (FALSE,FALSE);
  357.  
  358.    SRGP__disableLocatorRubberEcho();
  359.    SRGP__disableLocatorCursorEcho();
  360.  
  361.    srgp__cur_locator_echo_type = value;
  362.  
  363.    SRGP__enableLocatorRubberEcho();
  364.    SRGP__enableLocatorCursorEcho();
  365.  
  366. /* JJR
  367.    SRGP__updateInputSelectionMask();
  368. */
  369. }
  370.  
  371.    
  372. /*!*/
  373.  
  374. void
  375. SRGP_setLocatorEchoCursorShape (int id)
  376. {
  377.    DEBUG_AIDS{
  378.       SRGP_trace (SRGP_logStream, "SRGP_setLocatorEchoCursorShape %d\n", id);
  379.       srgp_check_system_state();
  380.       LeaveIfNonFatalErr();
  381.    }
  382.    SRGP__handleRawEvents (FALSE,FALSE);
  383.  
  384.    srgp__cur_cursor = id;
  385.  
  386.    SRGP__updateLocatorCursorShape ();
  387. }
  388.  
  389.  
  390. /*!*/
  391.  
  392. void
  393. SRGP_setLocatorEchoRubberAnchor (point position)
  394. {
  395.    DEBUG_AIDS{
  396.       SRGP_trace (SRGP_logStream, "SRGP_setLocatorEchoRubberAnchor %d,%d\n",
  397.           position.x, position.y);
  398.       srgp_check_system_state();
  399.       LeaveIfNonFatalErr();
  400.    }
  401.  
  402.    SRGP__handleRawEvents (FALSE,FALSE);
  403.  
  404.    srgp__cur_locator_echo_anchor = position;
  405.  
  406.    SRGP__updateLocatorRubberAnchor ();
  407. }
  408.  
  409.  
  410. /*!*/
  411.  
  412.  
  413. void
  414. SRGP_setLocatorButtonMask (int value)
  415. {
  416.    DEBUG_AIDS{
  417.       SRGP_trace (SRGP_logStream, "SRGP_setLocatorButtonMask %d\n", value);
  418.    }
  419.  
  420.    srgp__cur_locator_button_mask = value;
  421. }
  422.  
  423.  
  424. /*!*/
  425.  
  426.  
  427. void
  428. SRGP_setKeyboardProcessingMode (keyboardMode value)
  429. {
  430.    DEBUG_AIDS{
  431.       SRGP_trace (SRGP_logStream, "SRGP_setKeyboardProcessingMode %d\n", 
  432.           value);
  433.       srgp_check_system_state();
  434.       LeaveIfNonFatalErr();
  435.    }
  436.    SRGP__handleRawEvents (FALSE,FALSE);
  437.  
  438.    if (srgp__cur_mode[KEYBOARD] != INACTIVE)
  439.       SRGP__deactivateDevice (KEYBOARD);
  440.  
  441.    srgp__cur_keyboard_processing_mode = value;
  442.  
  443.    if (srgp__cur_mode[KEYBOARD] != INACTIVE)
  444.       SRGP__activateDevice (KEYBOARD);
  445. }
  446.  
  447.  
  448. /*!*/
  449.  
  450.  
  451. void
  452. SRGP_setKeyboardEchoColor (int value)
  453. {
  454.    DEBUG_AIDS{
  455.       SRGP_trace (SRGP_logStream, "SRGP_setKeyboardEchoColor %d\n", value);
  456.       srgp_check_system_state();
  457.       LeaveIfNonFatalErr();
  458.    }
  459.    SRGP__handleRawEvents (FALSE,FALSE);
  460.  
  461.    srgp__cur_keyboard_echo_color = value;
  462.    SRGP__updateKeyboardEchoAttributes();
  463. }
  464.  
  465.  
  466. /*!*/
  467.  
  468.  
  469. void
  470. SRGP_setKeyboardEchoOrigin (point position)
  471. {
  472.    DEBUG_AIDS{
  473.       SRGP_trace (SRGP_logStream, "SRGP_setKeyboardEchoOrigin %d,%d\n", 
  474.           position.x, position.y);
  475.       srgp_check_system_state();
  476.       LeaveIfNonFatalErr();
  477.    }
  478.    SRGP__handleRawEvents (FALSE,FALSE);
  479.  
  480.    srgp__cur_keyboard_echo_origin = position;
  481.    SRGP__updateKeyboardEchoAttributes();
  482. }
  483.  
  484.  
  485. /*!*/
  486.  
  487.  
  488. void
  489. SRGP_setKeyboardEchoFont (int fontindex)
  490. {
  491.    DEBUG_AIDS{
  492.       SRGP_trace (SRGP_logStream, "SRGP_setKeyboardEchoFont %d\n", fontindex);
  493.       srgp_check_system_state();
  494.       LeaveIfNonFatalErr();
  495.    }
  496.    SRGP__handleRawEvents (FALSE,FALSE);
  497.  
  498.    srgp__cur_keyboard_echo_font = fontindex;
  499.    SRGP__updateKeyboardEchoAttributes ();
  500. }
  501.  
  502.  
  503.  
  504.  
  505. /** SAMPLERS **/
  506.  
  507. void
  508. SRGP_sampleLocator (srgp__locator_measure *measure)
  509. {
  510.    DEBUG_AIDS{
  511.       srgp_check_system_state();
  512.       LeaveIfNonFatalErr();
  513.    }
  514.    SRGP__handleRawEvents (FALSE,FALSE);
  515. /*
  516.    if (srgp__dirty_location) 
  517.       SRGP__updateLocationKnowledge();
  518. */
  519.    *measure = *((srgp__locator_measure*)(&srgp__cur_locator_measure));
  520. }
  521.  
  522.  
  523. void
  524. SRGP_sampleDeluxeLocator (srgp__deluxe_locator_measure *measure)
  525. {
  526.    DEBUG_AIDS{
  527.       srgp_check_system_state();
  528.       LeaveIfNonFatalErr();
  529.    }
  530.    SRGP__handleRawEvents (FALSE,FALSE);
  531. /* JJR
  532.    if (srgp__dirty_location) 
  533.       SRGP__updateLocationKnowledge();
  534. */
  535.    *measure = srgp__cur_locator_measure;
  536.    ComputeTimestamp (&(measure->timestamp));
  537. }
  538.  
  539. /*!*/
  540.  
  541. void
  542. SRGP_sampleKeyboard (char *measure, int bufsize)
  543. {
  544.    DEBUG_AIDS{
  545.       srgp_check_system_state();
  546.       LeaveIfNonFatalErr();
  547.    }
  548.    SRGP__handleRawEvents (FALSE,FALSE);
  549.    strncpy (measure, srgp__cur_keyboard_measure.buffer, bufsize-1);
  550.    *(measure+bufsize-1) = '\0';
  551. }
  552.  
  553. void
  554. SRGP_sampleDeluxeKeyboard (srgp__deluxe_keyboard_measure *measure)
  555. {
  556.    DEBUG_AIDS{
  557.       srgp_check_system_state();
  558.       LeaveIfNonFatalErr();
  559.    }
  560.    SRGP__handleRawEvents (FALSE,FALSE);
  561.    strncpy (measure->buffer, srgp__cur_keyboard_measure.buffer, 
  562.         measure->buffer_length-1);
  563.    *(measure->buffer+measure->buffer_length-1) = '\0';
  564.    bcopy (srgp__cur_keyboard_measure.modifier_chord,
  565.       measure->modifier_chord,
  566.       sizeof(measure->modifier_chord));
  567.    measure->position = srgp__get_keyboard_measure.position;
  568.    ComputeTimestamp (&(measure->timestamp));
  569. }
  570.